#include <iostream>
class BaseClass {
  public:
    int PublicFunc() {
        std::cout << "执行父类公有成员函数\n";
        return 1;
    }; // 公有成员函数
    int m_pub;

  protected:
    int ProtectedFunc() {
        std::cout << "执行父类保护成员函数\n";
        return 1;
    }; // 保护成员函数
    int m_pro;

  private:
    int PrivateFunc() {
        std::cout << "执行父类私有成员函数\n";
        return 1;
    }; // 私有成员函数
    int m_priv;

  public
      : // 这里无论设置成什么都不影响对本类成员变量和成员函数的调用，只影响生成的对象对此函数的访问性。即对象可以访问public方法
    void process() {
        m_pub = 1;
        std::cout << "设置公共成员变量值为 " << m_pub << "\n";
        m_pro = 2;
        std::cout << "设置保护成员变量值为 " << m_pro << "\n";
        m_priv = 3;
        std::cout << "设置私有成员变量值为 " << m_priv << "\n";
        PublicFunc();
        ProtectedFunc();
        PrivateFunc();
    }
};

class DerivedClass1 : public BaseClass {
  public:
    // 公有继承的子类内部可以访问父类的公有和保护函数
    void Pubfoo() {
        std::cout << "公有继承,访问父类公有成员变量 " << m_pub
                  << " 保护成员变量 \n";
        PublicFunc();
        ProtectedFunc();
        // PrivateFunc(); // 子类内部无法访问父类的私有函数
    }

  protected:
    void Profoo() {
        PublicFunc(); // 类内部访问性和公有相同
        ProtectedFunc();
        // PrivateFunc(); // 子类内部无法访问父类的私有函数
    }
};

class DerivedClass2 : protected BaseClass {
  public:
    void foo() {
        std::cout << "保护继承\n";
        PublicFunc();
        ProtectedFunc();
    }
};

class DerivedClass3 : private BaseClass {
  public:
    void foo() {
        std::cout << "私有继承\n";
        PublicFunc();
        ProtectedFunc();
        // PrivateFunc();
    }
};

int main() {
    DerivedClass1 derived_class1;
    DerivedClass2 derived_class2;
    DerivedClass3 derived_class3;

    derived_class1.PublicFunc(); // 公有继承的对象能访问父类的公有函数
    // derived_class1.ProtectedFunc(); // 公有继承子类对象无法访问父类的保护函数
    // derived_class1.PrivateFunc(); // 子类对象无法访问父类的私有函数
    derived_class1.Pubfoo();

    // derived_class2.PublicFunc();//保护继承后子类对象无法访问父类的公有函数
    // derived_class2.ProtectedFunc();//保护继承后子类对象无法访问父类的保护函数
    // derived_class2.PrivateFunc();//子类对象无法访问父类的私有函数
    derived_class2.foo();
    //  derived_class2.PublicFunc(); // function is inaccessible
    //    derived_class3.PublicFunc(); //
    //    私有继承之后父类无法访问基类中的公有函数
    //    derived_class3.ProtectedFunc(); //
    //    私有继承之后父类无法访问基类中的保护函数 derived_class3
    //        .PrivateFunc(); // 私有函数对象永远无法访问,无论使用什么继承方式
    derived_class3.foo();
}
